package com.sdses.weather.config.mapping;//package com.sdses.weather.config.mapping;
//
//
//import cn.hutool.core.collection.CollUtil;
//import cn.hutool.core.util.StrUtil;
//import com.sdses.weather.common.MappingResult;
//import com.sdses.weather.config.WeatherProviderSchemaConfig;
//import com.sdses.weather.config.exception.BusinessException;
//import com.sdses.weather.utils.SortHelper;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.beanutils.PropertyUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.ApplicationContext;
//import org.springframework.stereotype.Component;
//
//import java.lang.reflect.Field;
//import java.text.SimpleDateFormat;
//import java.util.*;
//import java.util.concurrent.ConcurrentHashMap;
//import java.util.stream.Collectors;
//
//@Slf4j
//@Component
//public class WeatherMappingFiled {
//
//    @Autowired
//    private WeatherProviderSchemaConfig weatherProviderSchemaConfig;
//    @Autowired
//    private ApplicationContext applicationContext; // 用于获取 Converter Bean
//
//    // 字段缓存：提升反射性能
//    private static final ConcurrentHashMap<Class<?>, Map<String, Field>> FIELD_CACHE = new ConcurrentHashMap<>();
//
//    // ==================== 主入口：带全局上下文的列表映射 ====================
//    public <T, C> MappingResult<List<T>, C> mapDataListWithGlobal(
//            String json,
//            String provider,
//            String dataType,
//            Class<T> itemClass,
//            Class<C> contextClass) {
//
//        try {
//            WeatherProviderSchemaConfig.ProviderConfig providerConfig = weatherProviderSchemaConfig.getProvider(provider);
//
//            // 2. 获取数据类型配置
//            WeatherProviderSchemaConfig.DataTypeConfig typeConfig = WeatherProviderSchemaConfig.getDataTypeConfig(providerConfig, dataType);
//
//            // 3. 解析数据列表
//            List<T> itemList = mapDataList(json, providerConfig, typeConfig, itemClass, provider);
//
//            // 4. 解析全局上下文（如 baseTimestamp, conditionCode）
//            C context = (CollUtil.isNotEmpty(typeConfig.getContextFields()) && contextClass != null)
//                    ? parseContext(json, providerConfig.getBasePath(), typeConfig.getContextFields(), contextClass, provider)
//                    : WeatherMappingUtil.instantiate(contextClass); // 上下文无配置，返回空实例
//
//            // 5. 返回结果
//            MappingResult<List<T>, C> result = new MappingResult<>();
//            result.setData(itemList);
//            result.setContext(context);
//            return result;
//
//        } catch (Exception e) {
//            log.error("Failed to map data with global context [provider={}, dataType={}]", provider, dataType, e);
//            throw new BusinessException("数据映射失败: " + e.getMessage());
//        }
//    }
//
//    // ==================== 列表数据映射 ====================
//    private <T> List<T> mapDataList(
//            String json,
//            WeatherProviderSchemaConfig.ProviderConfig providerCfg,
//            WeatherProviderSchemaConfig.DataTypeConfig typeConfig,
//            Class<T> itemClass,
//            String provider) {
//
//        List<Map<String, Object>> dataList = WeatherMappingUtil.extractDataList(json, providerCfg, typeConfig);
//        if (dataList.isEmpty()) {
//            log.debug("No data extracted for provider='{}', dataType='{}'", providerCfg, typeConfig);
//            return Collections.emptyList();
//        }
//
//        List<T> result = dataList.stream()
//                .map(item -> mapItem(item, typeConfig.getFields(), itemClass, provider))
//                .filter(Objects::nonNull)
//                .collect(Collectors.toList());
//
//        // 按配置排序（如按时间戳升序）
//        return SortHelper.sortByConfig(result, typeConfig.getFields());
//    }
//
//    // ==================== 解析全局上下文 ====================
//    private <C> C parseContext(
//            String json,
//            String basePath,
//            List<WeatherProviderSchemaConfig.FieldMapping> contextFields,
//            Class<C> contextClass,
//            String provider) throws Exception {
//
//        C instance = WeatherMappingUtil.instantiate(contextClass);
//
//        for (WeatherProviderSchemaConfig.FieldMapping field : contextFields) {
//            String fullJsonPath = WeatherMappingUtil.joinJsonPath(basePath, field.getJson());
//            String targetField = WeatherMappingUtil.getTargetFieldName(field);
//
//            Object rawValue = WeatherMappingUtil.readJsonPath(json, fullJsonPath, Object.class);
//            if (rawValue == null) continue;
//
//            Object convertedValue = convertValue(rawValue.toString(), field, provider);
//            if (convertedValue != null) {
//                PropertyUtils.setProperty(instance, targetField, convertedValue);
//            }
//        }
//
//        return instance;
//    }
//
//    // ==================== 映射单个对象 ====================
//
//    private <T> T mapItem(
//            Map<String, Object> source,
//            List<WeatherProviderSchemaConfig.FieldMapping> fields,
//            Class<T> targetType,
//            String provider) {
//
//        if (source == null || fields == null || fields.isEmpty()) return null;
//
//        try {
//            T instance = WeatherMappingUtil.instantiate(targetType);
//
//            for (WeatherProviderSchemaConfig.FieldMapping field : fields) {
//                String jsonKey = field.getJson();
//                Object value = source.get(jsonKey);
//                if (value == null) continue;
//
//                String javaKey = WeatherMappingUtil.getTargetFieldName(field);
//                Field javaField = findField(targetType, javaKey);
//                if (javaField == null) continue;
//
//                Object convertedValue = convertValue(value.toString(), field, provider);
//                if (convertedValue != null) {
//                    javaField.set(instance, convertedValue);
//                }
//            }
//
//            return instance;
//
//        } catch (Exception e) {
//            log.error("Failed to map item to type: {}", targetType.getSimpleName(), e);
//            return null;
//        }
//    }
//
//
//    private Field findField(Class<?> clazz, String fieldName) {
//        return FIELD_CACHE
//                .computeIfAbsent(clazz, k -> {
//                    Map<String, Field> map = new HashMap<>();
//                    Class<?> current = k;
//                    while (current != null) {
//                        for (Field field : current.getDeclaredFields()) {
//                            if (!map.containsKey(field.getName())) { // 避免子类覆盖父类时重复
//                                map.put(field.getName(), field);
//                                if (!field.isAccessible()) {
//                                    field.setAccessible(true); // ✅ 提前开启
//                                }
//                            }
//                        }
//                        current = current.getSuperclass();
//                    }
//                    return map;
//                })
//                .get(fieldName);
//    }
//
//
//    public Object convertValue(Object value, WeatherProviderSchemaConfig.FieldMapping field, String provider) {
//        if (value == null) {
//            return null;
//        }
//
//        // 1. 自定义转换器
//        if (StrUtil.isNotBlank(field.getConverter())) {
//            try {
//                Object converterBean = applicationContext.getBean(field.getConverter().trim());
//                if (converterBean instanceof FieldConverter) {
//                    @SuppressWarnings("unchecked")
//                    FieldConverter<Object> converter = (FieldConverter<Object>) converterBean;
//                    return converter.convert(value, provider);
//                }
//            } catch (Exception e) {
//                log.error("转换器调用失败: " + field.getConverter(), e);
//            }
//        }
//
//        // 2. 默认类型转换
//        String type = field.getType();
//        String strValue = value.toString().trim();
//
//        if ("string".equalsIgnoreCase(type)) {
//            return strValue;
//        } else if ("int".equalsIgnoreCase(type) || "integer".equalsIgnoreCase(type)) {
//            try {
//                return Integer.valueOf(strValue);
//            } catch (NumberFormatException e) {
//                log.error("int 转换失败: " + strValue);
//                return null;
//            }
//        } else if ("long".equalsIgnoreCase(type)) {
//            try {
//                return Long.valueOf(strValue);
//            } catch (NumberFormatException e) {
//                log.error("long 转换失败: " + strValue);
//                return null;
//            }
//        } else if ("double".equalsIgnoreCase(type) || "float".equalsIgnoreCase(type)) {
//            try {
//                return Double.valueOf(strValue);
//            } catch (NumberFormatException e) {
//                log.error("double 转换失败: " + strValue);
//                return null;
//            }
//        } else if ("boolean".equalsIgnoreCase(type)) {
//            return Boolean.valueOf(strValue);
//        } else if ("date".equalsIgnoreCase(type)) {
//            String format = field.getSortFormat();
//            if (format != null && !format.trim().isEmpty()) {
//                try {
//                    return new SimpleDateFormat(format.trim()).parse(strValue);
//                } catch (Exception e) {
//                    log.error("日期格式转换失败: format=" + format + ", value=" + strValue);
//                }
//            }
//            return new Date(); // 默认返回当前时间
//        } else if ("enum".equalsIgnoreCase(type)) {
//            log.warn("enum 类型应由转换器处理，字段: " + field.getJava());
//            return null;
//        } else {
//            return value;
//        }
//    }
//
//}
